
<html><head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta content="text/javascript" http-equiv="content-script-type">
<title>system.Hash</title>
<link rel="stylesheet" type="text/css" href="candydoc/style.css">
<!--[if lt IE 7]><link rel="stylesheet" type="text/css" href="candydoc/ie56hack.css"><![endif]-->
<script language="JavaScript" src="candydoc/util.js" type="text/javascript"></script>
<script language="JavaScript" src="candydoc/tree.js" type="text/javascript"></script>
<script language="JavaScript" src="candydoc/explorer.js" type="text/javascript"></script>
</head><body>
<div id="tabarea"></div><div id="explorerclient"></div>
<div id="content"><script>explorer.initialize("system.Hash");</script>
	<table class="content">
		<tr><td id="docbody"><h1>system.Hash</h1><!-- Generated by Ddoc from F:\MyWork\phoenix\source\system\Hash.d -->
散列模块
<br><br>
<b>License:</b><br>
BSD
<br><br>
<b>Author:</b><br>
Bob Jenkins
<br><br>
<b>Modifier:</b><br>
Lucifer(786325481@QQ.com)
<br><br>
<b>Date:</b><br>
11-8-2007
<br><br>


<script>explorer.outline.incSymbolLevel();</script>
<dl>
<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">hash_t 
<span class="currsymbol">toHash</span>
<script>explorer.outline.addDecl('toHash');</script>

(T)(T <span class="funcparam">obj</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>通用散列函数
<br><br>
<b>Params:</b><br>
<table><tr>
<td nowrap valign="top" style="padding-right: 8px">obj</td>

               
<td>要散列的对象</td></tr>
</table><br>
<b>Returns:</b><br>
一个 32bit 大小的数字
<br><br>
<b>Comments:</b><br>
如果需要其他散列算法的函数，可以使用自由函数实现；
           如果在类/结构内实现 
<span class="currsymbol">toHash</span>
<script>explorer.outline.addDecl('toHash');</script>

() 函数，该泛型函数也可以调用。
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">hash_t 
<span class="currsymbol">getHash</span>
<script>explorer.outline.addDecl('getHash');</script>

(T)(T <span class="funcparam">value</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>字符串与数组散列函数 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">const int 
<span class="currsymbol">HashLittleEndian</span>
<script>explorer.outline.addDecl('HashLittleEndian');</script>

;
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>These are functions for producing 32-bit hashes for hash table lookup.
 hashWord(), hashLittle(), hashBig(), mix(), and last()
 are externally useful functions.
<br><br>
You probably want to use hashLittle().  hashLittle() and hashBig()
 hash byte arrays.  hashLittle() is is faster than hashBig() on
 little-endian machines.  Intel and AMD are little-endian machines.
 On second thought, you probably want hashLittle(void* key, size_t length, uint* pc, uint* pb),
 which is identical to hashLittle() except it returns two 32-bit hashes for the price of one.

<br><br>
<b>Examples:</b><br>
<pre class="d_code"> If you want to find a hash of, say, exactly 7 integers, <font color=blue>do</font>
 a = i1;  b = i2;  c = i3;
 mix(a,b,c);
 a += i4; b += i5; c += i6;
 mix(a,b,c);
 a += i7;
 last(a,b,c);
 then use c as the hash value.  If you have a variable length array of
 4-<font color=blue>byte</font> integers to hash, use hashWord().  If you have a <font color=blue>byte</font> array (like
 a character string), use hashLittle().  If you have several <font color=blue>byte</font> arrays, or
 a mix of things, see the comments above hashLittle().
</pre>

 Why is this so big?  I read 12 bytes at a time into 3 4-byte integers,
 then mix those integers.  This is fast (you can do a lot more thorough
 mixing with 12*3 instructions on 3 integers than you can with 3 instructions
 on 1 byte), but shoehorning those bytes into integers efficiently is messy.
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">const int 
<span class="currsymbol">HashBigEndian</span>
<script>explorer.outline.addDecl('HashBigEndian');</script>

;
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>These are functions for producing 32-bit hashes for hash table lookup.
 hashWord(), hashLittle(), hashBig(), mix(), and last()
 are externally useful functions.
<br><br>
You probably want to use hashLittle().  hashLittle() and hashBig()
 hash byte arrays.  hashLittle() is is faster than hashBig() on
 little-endian machines.  Intel and AMD are little-endian machines.
 On second thought, you probably want hashLittle(void* key, size_t length, uint* pc, uint* pb),
 which is identical to hashLittle() except it returns two 32-bit hashes for the price of one.

<br><br>
<b>Examples:</b><br>
<pre class="d_code"> If you want to find a hash of, say, exactly 7 integers, <font color=blue>do</font>
 a = i1;  b = i2;  c = i3;
 mix(a,b,c);
 a += i4; b += i5; c += i6;
 mix(a,b,c);
 a += i7;
 last(a,b,c);
 then use c as the hash value.  If you have a variable length array of
 4-<font color=blue>byte</font> integers to hash, use hashWord().  If you have a <font color=blue>byte</font> array (like
 a character string), use hashLittle().  If you have several <font color=blue>byte</font> arrays, or
 a mix of things, see the comments above hashLittle().
</pre>

 Why is this so big?  I read 12 bytes at a time into 3 4-byte integers,
 then mix those integers.  This is fast (you can do a lot more thorough
 mixing with 12*3 instructions on 3 integers than you can with 3 instructions
 on 1 byte), but shoehorning those bytes into integers efficiently is messy.
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">void 
<span class="currsymbol">mix</span>
<script>explorer.outline.addDecl('mix');</script>

(ref uint <span class="funcparam">a</span>, ref uint <span class="funcparam">b</span>, ref uint <span class="funcparam">c</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>
<span class="currsymbol">mix</span>
<script>explorer.outline.addDecl('mix');</script>

 three 32-bit values reversibly.
<br><br>
This is reversible, so any information in (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>) before 
<span class="currsymbol">mix</span>
<script>explorer.outline.addDecl('mix');</script>

() is
 still in (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>) after 
<span class="currsymbol">mix</span>
<script>explorer.outline.addDecl('mix');</script>

().
<br><br>

 If four pairs of (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>) inputs are run through 
<span class="currsymbol">mix</span>
<script>explorer.outline.addDecl('mix');</script>

(), or through
 
<span class="currsymbol">mix</span>
<script>explorer.outline.addDecl('mix');</script>

() in reverse, there are at least 32 bits of the output that
 are sometimes the same for one pair and different for another pair.
 This was tested for:
 pairs that differed by one bit, by two bits, in any combination
 of top bits of (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>), or in any combination of bottom bits of
 (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>).
 "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
 the output delta to <span class="funcparam">a</span> Gray code (<span class="funcparam">a</span>^(<span class="funcparam">a</span>&gt;&gt;1)) so <span class="funcparam">a</span> string of 1's (as
 is commonly produced by subtraction) look like <span class="funcparam">a</span> single 1-bit
 difference.
 the base values were pseudorandom, all zero but one bit set, or
 all zero plus <span class="funcparam">a</span> counter that starts at zero.
<br><br>

 Some k values for my "<span class="funcparam">a</span>-=<span class="funcparam">c</span>; <span class="funcparam">a</span>^=rot(<span class="funcparam">c</span>,k); <span class="funcparam">c</span>+=<span class="funcparam">b</span>;" arrangement that
 satisfy this are
   4  6  8 16 19  4
   9 15  3 18 27 15
  14  9  3  7 17  3
 Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
 for "differ" defined as + with <span class="funcparam">a</span> one-bit base and <span class="funcparam">a</span> two-bit delta.  I
 used http://burtleburtle.net/bob/hash/avalanche.html to choose
 the operations, constants, and arrangements of the variables.
<br><br>

 This does not achieve avalanche.  There are input bits of (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>)
 that fail to affect some output bits of (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>), especially of <span class="funcparam">a</span>.  The
 most thoroughly mixed value is <span class="funcparam">c</span>, but it doesn't really even achieve
 avalanche in <span class="funcparam">c</span>.
<br><br>

 This allows some parallelism.  Read-after-writes are good at doubling
 the number of bits affected, so the goal of mixing pulls in the opposite
 direction as the goal of parallelism.  I did what I could.  Rotates
 seem to cost as much as shifts on every machine I could lay my hands
 on, and rotates are much kinder to the top and bottom bits, so I used
 rotates.
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">void 
<span class="currsymbol">last</span>
<script>explorer.outline.addDecl('last');</script>

(ref uint <span class="funcparam">a</span>, ref uint <span class="funcparam">b</span>, ref uint <span class="funcparam">c</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>
<span class="currsymbol">last</span>
<script>explorer.outline.addDecl('last');</script>

 mixing of 3 32-bit values (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>) into <span class="funcparam">c</span>
<br><br>
Pairs of (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>) values differing in only <span class="funcparam">a</span> few bits will usually
 produce values of <span class="funcparam">c</span> that look totally different.  This was tested for
 pairs that differed by one bit, by two bits, in any combination
 of top bits of (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>), or in any combination of bottom bits of
 (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>).
 "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
 the output delta to <span class="funcparam">a</span> Gray code (<span class="funcparam">a</span>^(<span class="funcparam">a</span>&gt;&gt;1)) so <span class="funcparam">a</span> string of 1's (as
 is commonly produced by subtraction) look like <span class="funcparam">a</span> single 1-bit
 difference.
 the base values were pseudorandom, all zero but one bit set, or
 all zero plus <span class="funcparam">a</span> counter that starts at zero.
<br><br>

 These constants passed:
 14 11 25 16 4 14 24
 12 14 25 16 4 14 24
 and these came close:
   4  8 15 26 3 22 24
 10  8 15 26 3 22 24
 11  8 15 26 3 22 24
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">uint 
<span class="currsymbol">hashWord</span>
<script>explorer.outline.addDecl('hashWord');</script>

(uint* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint <span class="funcparam">initval</span> = 0);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>This works on all machines.  To be useful, it requires
 that the <span class="funcparam">key</span> be an array of uint's, and
 that the <span class="funcparam">length</span> be the number of uint's in the <span class="funcparam">key</span>
<br><br>
The function 
<span class="currsymbol">hashWord</span>
<script>explorer.outline.addDecl('hashWord');</script>

() is identical to hashLittle() on little-endian
 machines, and identical to hashBig() on big-endian machines,
 except that the <span class="funcparam">length</span> has to be measured in uint rather than in
 bytes.  hashLittle() is more complicated than 
<span class="currsymbol">hashWord</span>
<script>explorer.outline.addDecl('hashWord');</script>

() only because
 hashLittle() has to dance around fitting the <span class="funcparam">key</span> bytes into registers.
  
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">void 
<span class="currsymbol">hashWord</span>
<script>explorer.outline.addDecl('hashWord');</script>

(uint* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint* <span class="funcparam">pc</span>, uint* <span class="funcparam">pb</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>Same as 
<span class="currsymbol">hashWord</span>
<script>explorer.outline.addDecl('hashWord');</script>

(uint* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint initval = 0), but take two seeds and return two
 32-bit values.  <span class="funcparam">pc</span> and <span class="funcparam">pb</span> must both be nonnull, and *<span class="funcparam">pc</span> and *<span class="funcparam">pb</span> must
 both be initialized with seeds.  If you pass in (*<span class="funcparam">pb</span>)==0, the output
 (*<span class="funcparam">pc</span>) will be the same as the return value from 
<span class="currsymbol">hashWord</span>
<script>explorer.outline.addDecl('hashWord');</script>

(uint* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint initval = 0).
 

<br><br>
<b>Params:</b><br>
<table></table><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">uint 
<span class="currsymbol">hashLittle</span>
<script>explorer.outline.addDecl('hashLittle');</script>

(void* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint <span class="funcparam">initval</span> = 0);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>hash a variable-<span class="funcparam">length</span> <span class="funcparam">key</span> into a 32-bit value
<br><br>
<b>Params:</b><br>
<table></table><br>
<b>Returns:</b><br>
a 32-bit value.
<br><br>
<b>Comments:</b><br>
Every bit of the <span class="funcparam">key</span> affects every bit of
                     the return value.  Two keys differing by one or two bits will have
                     totally different hash values.
<br><br>

 The best hash table sizes are powers of 2.  There is no need to do
 mod a prime (mod is sooo slow!).  If you need less than 32 bits,
 use a bitmask.  For example, if you need only 10 bits, do
 h = (h &amp; hashmask(10));
 In which case, the hash table should have hashsize(10) elements.
<br><br>

 If you are hashing n strings (char**)k, do it like this:
 for (i=0, h=0; i&lt;n; ++i) h = 
<span class="currsymbol">hashLittle</span>
<script>explorer.outline.addDecl('hashLittle');</script>

( k[i], len[i], h);
<br><br>

 By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this
 code any way you wish, private, educational, or commercial.  It's free.
<br><br>

 Use for hash table lookup, or anything where one collision in 2^^32 is
 acceptable.  Do NOT use for cryptographic purposes.
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">void 
<span class="currsymbol">hashLittle</span>
<script>explorer.outline.addDecl('hashLittle');</script>

(void* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint* <span class="funcparam">pc</span>, uint* <span class="funcparam">pb</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd><b>Returns:</b><br>
two 32-bit hash values
<br><br>

 This is identical to 
<span class="currsymbol">hashLittle</span>
<script>explorer.outline.addDecl('hashLittle');</script>

(void* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint initval = 0), except it returns two 32-bit hash
 values instead of just one.  This is good enough for hash table
 lookup with 2^^64 buckets, or if you want a second hash if you're not
 happy with the first, or if you want a probably-unique 64-bit ID for
 the <span class="funcparam">key</span>.  *<span class="funcparam">pc</span> is better mixed than *<span class="funcparam">pb</span>, so use *<span class="funcparam">pc</span> first.  If you want
 a 64-bit value do something like "*<span class="funcparam">pc</span> + ((cast(ulong)*<span class="funcparam">pb</span>)&lt;&lt;32)".
 

<br><br>
<b>Params:</b><br>
<table></table><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">uint 
<span class="currsymbol">hashBig</span>
<script>explorer.outline.addDecl('hashBig');</script>

(void* <span class="funcparam">key</span>, size_t <span class="funcparam">length</span>, uint <span class="funcparam">initval</span> = 0);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>This is the same as hashWord() on big-endian machines.  It is different
 from hashLittle() on all machines.  
<span class="currsymbol">hashBig</span>
<script>explorer.outline.addDecl('hashBig');</script>

() takes advantage of
 big-endian byte ordering.
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">void 
<span class="currsymbol">mix64</span>
<script>explorer.outline.addDecl('mix64');</script>

(ref ulong <span class="funcparam">a</span>, ref ulong <span class="funcparam">b</span>, ref ulong <span class="funcparam">c</span>);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>mix three 64-bit values reversibly.
 
<span class="currsymbol">mix64</span>
<script>explorer.outline.addDecl('mix64');</script>

() takes 48 machine instructions, but only 24 cycles on <span class="funcparam">a</span> superscalar
 machine (like Intel's new MMX architecture).  It requires 4 64-bit
 registers for 4::2 parallelism.
 All 1-bit deltas, all 2-bit deltas, all deltas composed of top bits of
 (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>), and all deltas of bottom bits were tested.  All deltas were
 tested both on random keys and on keys that were nearly all zero.
 These deltas all cause every bit of <span class="funcparam">c</span> to change between 1/3 and 2/3
 of the time (well, only 113/400 to 287/400 of the time for some
 2-bit delta).  These deltas all cause at least 80 bits to change
 among (<span class="funcparam">a</span>,<span class="funcparam">b</span>,<span class="funcparam">c</span>) when the mix is run either forward or backward (yes it
 is reversible).
 This implies that <span class="funcparam">a</span> hash using 
<span class="currsymbol">mix64</span>
<script>explorer.outline.addDecl('mix64');</script>

 has no funnels.  There may be
 characteristics with 3-bit deltas or bigger, I didn't test for those.
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">ulong 
<span class="currsymbol">hash64</span>
<script>explorer.outline.addDecl('hash64');</script>

(ubyte* <span class="funcparam">k</span>, ulong <span class="funcparam">length</span>, ulong <span class="funcparam">level</span> = 0);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>hash a variable-<span class="funcparam">length</span> key into a 64-bit value
 Returns a 64-bit value.  Every bit of the key affects every bit of
 the return value.  No funnels.  Every 1-bit and 2-bit delta achieves
 avalanche.  About 41+5len instructions.
<br><br>
The best hash table sizes are powers of 2.  There is no need to do
 mod a prime (mod is sooo slow!).  If you need less than 64 bits,
 use a bitmask.  For example, if you need only 10 bits, do
 h = (h &amp; hashMask64(10));
 In which case, the hash table should have hashSize(10) elements.
<br><br>

 If you are hashing n strings (ubyte**)<span class="funcparam">k</span>, do it like this:
 for (i=0, h=0; i&lt;n; ++i) h = 
<span class="currsymbol">hash64</span>
<script>explorer.outline.addDecl('hash64');</script>

( <span class="funcparam">k</span>[i], len[i], h);
<br><br>

 By Bob Jenkins, Jan 4 1997.  bob_jenkins@burtleburtle.net.  You may
 use this code any way you wish, private, educational, or commercial,
 but I would appreciate if you give me credit.

<br><br>
<b>See:</b><br>
<br><br>
<b>http:</b><br>
//burtleburtle.net/bob/hash/evahash.html
 Use for hash table lookup, or anything where one collision in 2^^64
 is acceptable.  Do NOT use for cryptographic purposes.
 

<br><br>
<b>Params:</b><br>
<table></table><br>
<b>Returns:</b><br>
a 64-bit value.
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">ulong 
<span class="currsymbol">hash64</span>
<script>explorer.outline.addDecl('hash64');</script>

(ulong* <span class="funcparam">k</span>, ulong <span class="funcparam">length</span>, ulong <span class="funcparam">level</span> = 0);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>This works on all machines, is identical to 
<span class="currsymbol">hash64</span>
<script>explorer.outline.addDecl('hash64');</script>

(ubyte* <span class="funcparam">k</span>, ...) on little-endian
 machines, and it is much faster than 
<span class="currsymbol">hash64</span>
<script>explorer.outline.addDecl('hash64');</script>

(ubyte* <span class="funcparam">k</span>, ...), but it requires
 -- that the key be an array of ulong's, and
 -- that all your machines have the same endianness, and
 -- that the <span class="funcparam">length</span> be the number of ulong's in the key
 
<br><br>

</dd>

<script>explorer.outline.writeEnabled = true;</script>
<dt><span class="decl">ulong 
<span class="currsymbol">hash64II</span>
<script>explorer.outline.addDecl('hash64II');</script>

(ubyte* <span class="funcparam">k</span>, ulong <span class="funcparam">length</span>, ulong <span class="funcparam">level</span> = 0);
</span></dt>
<script>explorer.outline.writeEnabled = false;</script>


<dd>This is identical to hash64(ubyte* <span class="funcparam">k</span>, ...) on little-endian machines, and it is much
 faster than hash64(ubyte* <span class="funcparam">k</span>, ...), but a little slower than hash64(ulong*<span class="funcparam">k</span>, ...), and it requires
 -- that all your machines be little-endian, for example all Intel x86
  chips or all VAXen.  It gives wrong results on big-endian machines.
 
<br><br>

</dd>
</dl>
<script>explorer.outline.decSymbolLevel();</script>


</td></tr>
		<tr><td id="docfooter">
			Page was generated with
			<img src="candydoc/img/candydoc.gif" style="vertical-align:middle; position:relative; top:-1px">
			on Sat Nov 29 22:33:12 2008

		</td></tr>
	</table>
</div>
<script>
	explorer.packageExplorer.addModule("platform.PAL");
	explorer.packageExplorer.addModule("platform.windows.Core");
	explorer.packageExplorer.addModule("platform.linux.Core");
	explorer.packageExplorer.addModule("system.Array");
	explorer.packageExplorer.addModule("system.BitArray");
	explorer.packageExplorer.addModule("system.Environment");
	explorer.packageExplorer.addModule("system.Event");
	explorer.packageExplorer.addModule("system.Exception");
	explorer.packageExplorer.addModule("system.Hash");
	explorer.packageExplorer.addModule("system.IntPtr");
	explorer.packageExplorer.addModule("system.Random");
	explorer.packageExplorer.addModule("system.Traits");
	explorer.packageExplorer.addModule("system.TypeTuple");
	explorer.packageExplorer.addModule("system.math.IEEE");
	explorer.packageExplorer.addModule("system.math.Math");
	explorer.packageExplorer.addModule("system.runtime.c.complex");
	explorer.packageExplorer.addModule("system.runtime.c.config");
	explorer.packageExplorer.addModule("system.runtime.c.ctype");
	explorer.packageExplorer.addModule("system.runtime.c.errno");
	explorer.packageExplorer.addModule("system.runtime.c.fenv");
	explorer.packageExplorer.addModule("system.runtime.c.inttypes");
	explorer.packageExplorer.addModule("system.runtime.c.limits");
	explorer.packageExplorer.addModule("system.runtime.c.locale");
	explorer.packageExplorer.addModule("system.runtime.c.math");
	explorer.packageExplorer.addModule("system.runtime.c.signal");
	explorer.packageExplorer.addModule("system.runtime.c.stdarg");
	explorer.packageExplorer.addModule("system.runtime.c.stddef");
	explorer.packageExplorer.addModule("system.runtime.c.stdint");
	explorer.packageExplorer.addModule("system.runtime.c.stdio");
	explorer.packageExplorer.addModule("system.runtime.c.stdlib");
	explorer.packageExplorer.addModule("system.runtime.c.string");
	explorer.packageExplorer.addModule("system.runtime.c.time");
	explorer.packageExplorer.addModule("system.runtime.c.wctype");
	explorer.packageExplorer.addModule("system.text.UTF");
	explorer.packageExplorer.addModule("system.threading.Atomic");
	explorer.packageExplorer.addModule("system.threading.ThreadUtility");
	explorer.packageExplorer.addModule("system.threading.synchronization.SpinWait");
	explorer.packageExplorer.addModule("system.collections.ArrayList");
	explorer.packageExplorer.addModule("system.collections.Comparer");
	explorer.packageExplorer.addModule("system.collections.Deque");
	explorer.packageExplorer.addModule("system.collections.EqualityComparer");
	explorer.packageExplorer.addModule("system.collections.Exception");
	explorer.packageExplorer.addModule("system.collections.HashMap");
	explorer.packageExplorer.addModule("system.collections.HashSet");
	explorer.packageExplorer.addModule("system.collections.ICollection");
	explorer.packageExplorer.addModule("system.collections.IComparer");
	explorer.packageExplorer.addModule("system.collections.IDeque");
	explorer.packageExplorer.addModule("system.collections.IEnumerable");
	explorer.packageExplorer.addModule("system.collections.IEnumerator");
	explorer.packageExplorer.addModule("system.collections.IEqualityComparer");
	explorer.packageExplorer.addModule("system.collections.IList");
	explorer.packageExplorer.addModule("system.collections.IMap");
	explorer.packageExplorer.addModule("system.collections.IQueue");
	explorer.packageExplorer.addModule("system.collections.LinkedList");
	explorer.packageExplorer.addModule("system.collections.Pair");
	explorer.packageExplorer.addModule("system.collections.PrimeHelper");
	explorer.packageExplorer.addModule("system.collections.PriorityQueue");
	explorer.packageExplorer.addModule("system.collections.Queue");
	explorer.packageExplorer.addModule("system.collections.RBTree");
	explorer.packageExplorer.addModule("system.collections.Stack");
	explorer.packageExplorer.addModule("system.collections.TreeMap");
	explorer.packageExplorer.addModule("system.collections.TreeSet");
	explorer.packageExplorer.addModule("system.collections.objectmodel.ListCollection");
	explorer.packageExplorer.addModule("system.collections.objectmodel.ReadOnlyListCollection");</script>
</body></html>


